home *** CD-ROM | disk | FTP | other *** search
/ QuickTime 2.0 Developer Kit / QuickTime 2.0 Developer Kit.iso / mac / MAC / Programming Stuff / Interfaces / RIncludes / MixedMode.r < prev    next >
Encoding:
Text File  |  1994-02-14  |  9.7 KB  |  316 lines  |  [TEXT/MPS ]
  1. /*
  2.     File:        MixedMode.r
  3.  
  4.     Contains:    Rez templates for creating resource based Mixed Mode stuff
  5.  
  6.     Written by:    Bruce Jones
  7.  
  8.     Copyright:    © 1993-1994 by Apple Computer, Inc., all rights reserved.
  9.  
  10.     Change History (most recent first):
  11.  
  12.          <9>      2/9/94    M        <BKJ> (#1140370) sdes doesn't work with old ROMS.
  13.          <8>    11/19/93    M        <BKJ> (#1126144) Remove private ISA types
  14.          <7>     9/15/93    EPT        <EPT, jrc> (#1112486) Added ALIGN directives to the rez
  15.                                     templates for fat and safe fat resources.
  16.          <6>     9/14/93    EPT        <EPT, jrc> (#1112486) Added rez template for safe fat resources.
  17.          <5>     7/23/93    BKJ        Add support for fat routine descriptors. (BRC #1088593)
  18.          <4>     5/10/93    jrc        The RoutineFlags bits are in the wrong order.  Fix them.
  19.          <3>      5/5/93    BKJ        Update to latest version of Routine Descriptors.
  20.          <2>      3/8/93    BKJ        Fix bug in definition of rdes.  Revise example.
  21.          <1>     2/26/93    BKJ        first checked in
  22. */
  23.  
  24.  
  25.  
  26. #define    GoMixedModeTrapType    unsigned hex integer
  27. #define    VersionType byte
  28. #define    SelectorsAreIndexableType boolean
  29. #define    Reserved1Type fill long
  30. #define    Reserved2Type fill byte
  31. #define    SelectorInfoType hex byte
  32. #define    RoutineCountType integer
  33.  
  34. #define ProcInfoType binary longint
  35. #define    Reserved3Type fill byte
  36. #define    ISAType byte
  37. #define ProcDescriptorIsRelativeType boolean
  38. #define    FragmentNeedsPreparingType boolean
  39. #define    UseNativeISAType boolean
  40. #define    DontPassSelectorType boolean
  41. #define    RoutineIsDispatchedDefaultType boolean
  42. #define    ProcDescriptorType longint
  43. #define    Reserved4Type fill long
  44. #define    SelectorType longint
  45.  
  46. #define    _MixedModeMagic 0xAAFE
  47. #define    kRoutineDescriptorVersion 7
  48.  
  49. #define    kM68kISA 0
  50. #define    kPowerPCISA 1
  51.  
  52. /*
  53.     Use the 'rdes' template to define a “native resource” which 
  54.     starts with a routine descriptor. Such resources contain 
  55.     just PowerPC code. 
  56.     
  57.     Note that such resources can only be executed on PowerPC
  58.     machines. Executing them on a 68K machine will result 
  59.     in a crash.
  60.  
  61.     To create a “native resource”, use something like the following:
  62.     
  63. #include "MixedMode.r"
  64.  
  65. type 'BDef' as 'rdes';
  66.  
  67. resource 'BDef' (1) {
  68.     $1,                                        // ProcInfo
  69.     $$Resource("BDef.rsrc", 'pCod', 128)    // Specify name, type, and ID of resource
  70.                                             //   containing a pef container
  71. };
  72.  
  73. */
  74.  
  75. type 'rdes' { 
  76. Top:
  77.     /* Routine Descriptor */
  78.     GoMixedModeTrapType             = _MixedModeMagic;
  79.     VersionType                        = kRoutineDescriptorVersion;
  80.     fill bit [7];
  81.     SelectorsAreIndexableType        = FALSE;
  82.     Reserved1Type;
  83.     Reserved2Type;
  84.     SelectorInfoType                = 0;
  85.     RoutineCountType                = 0;
  86.  
  87.     /* Routine Record */
  88.     ProcInfoType;
  89.     Reserved3Type;
  90.     ISAType                            = kPowerPCISA;
  91.     fill bit [11];
  92.     RoutineIsDispatchedDefaultType     = FALSE;
  93.     DontPassSelectorType            = FALSE;
  94.     UseNativeISAType                = TRUE;
  95.     FragmentNeedsPreparingType        = TRUE;
  96.     ProcDescriptorIsRelativeType    = TRUE;
  97.     ProcDescriptorType                = (BeginningOfPowerPCCode-Top) / 8;
  98.     Reserved4Type;
  99.     SelectorType                    = 0;
  100.     Align LONG;
  101.  
  102. BeginningOfPowerPCCode:
  103.     hex string;                        // The PEF container starts here
  104. };
  105.  
  106.  
  107. /*
  108.     Use the 'fdes' template to define a “fat resource” which 
  109.     starts with a routine descriptor and contains both 68K and 
  110.     PowerPC code. 
  111.     
  112.     Note that such resources can only be executed on a machine
  113.     with MixedMode installed. To create “safe fat resources”
  114.     which will run on all machines, use the 'sdes' template
  115.     defined below.
  116.  
  117.     To create a “fat resource”, use something like the following:
  118.     
  119. #include "MixedMode.r"
  120.  
  121. type 'BDef' as 'fdes';
  122.  
  123. resource 'BDef' (1) {
  124.     $1,                                        // 68K ProcInfo
  125.     $1,                                        // PowerPC ProcInfo
  126.     $$Resource("BDef.rsrc", 'oCod', 128),    // Specify name, type, and ID of resource
  127.                                             //   containing 68k code
  128.     $$Resource("BDef.rsrc", 'pCod', 128)    // Specify name, type, and ID of resource
  129.                                             //   containing a pef container
  130. };
  131.  
  132. */
  133.  
  134. /*  Fat Routines  */
  135. type 'fdes' { 
  136. Top:
  137.     /* Routine Descriptor */
  138.     GoMixedModeTrapType             = _MixedModeMagic;
  139.     VersionType                        = kRoutineDescriptorVersion;
  140.     fill bit [7];
  141.     SelectorsAreIndexableType        = FALSE;
  142.     Reserved1Type;
  143.     Reserved2Type;
  144.     SelectorInfoType                = 0;
  145.     RoutineCountType                = 1;
  146.  
  147.     /* 68k Routine Record */
  148.     ProcInfoType;
  149.     Reserved3Type;
  150.     ISAType                            = kM68kISA;
  151.     fill bit [11];
  152.     RoutineIsDispatchedDefaultType     = FALSE;
  153.     DontPassSelectorType            = FALSE;
  154.     UseNativeISAType                = TRUE;
  155.     FragmentNeedsPreparingType        = FALSE;
  156.     ProcDescriptorIsRelativeType    = TRUE;
  157.     ProcDescriptorType                = (BeginningOf68KCode-Top) / 8;
  158.     Reserved4Type;
  159.     SelectorType                    = 0;
  160.  
  161.     /* PowerPC Routine Record 1 */
  162.     ProcInfoType;
  163.     Reserved3Type;
  164.     ISAType                            = kPowerPCISA;
  165.     fill bit [11];
  166.     RoutineIsDispatchedDefaultType     = FALSE;
  167.     DontPassSelectorType            = FALSE;
  168.     UseNativeISAType                = TRUE;
  169.     FragmentNeedsPreparingType        = TRUE;
  170.     ProcDescriptorIsRelativeType    = TRUE;
  171.     ProcDescriptorType                = (BeginningOfPowerPCCode-Top) / 8;
  172.     Reserved4Type;
  173.     SelectorType                    = 0;
  174.     Align LONG;
  175.  
  176. BeginningOf68kCode:
  177.     hex string;                // The code starts here
  178.     
  179.     Align LONG;
  180.  
  181. BeginningOfPowerPCCode:
  182.     hex string;                // The PEF container starts here
  183. };
  184.  
  185.  
  186. /*
  187.     Use the 'sdes' template to define a “safe fat resource” which 
  188.     contains both 68K and PowerPC code. A safe fat resource starts
  189.     with 68K code which is executed the first time the resource
  190.     is called. This code determines if MixedMode is present. If
  191.     so, a routine descriptor is moved to the beginning of the
  192.     resource. If not, a branch instruction to the 68K portion
  193.     of the code is placed at the beginning of the resource. 
  194.     Therefore, the first time the resource is executed, there 
  195.     is some overhead incurred. However, subsequent calls 
  196.     will be fast.
  197.     
  198.     Note: This template cannot currently be used for resources
  199.     containing code with register-based calling conventions
  200.     because the 68K code at the beginning of the resource
  201.     uses D0, A0, and A1.
  202.     
  203.     To create a “safe fat resource”, use something like the following:
  204.     
  205. #include "MixedMode.r"
  206.  
  207. type 'BDef' as 'sdes';
  208.  
  209. resource 'BDef' (1) {
  210.     $1,                                        // 68K ProcInfo
  211.     $1,                                        // PowerPC ProcInfo
  212.     $$Resource("BDef.rsrc", 'oCod', 128),    // Specify name, type, and ID of resource
  213.                                             //   containing 68k code
  214.     $$Resource("BDef.rsrc", 'pCod', 128)    // Specify name, type, and ID of resource
  215.                                             //   containing a pef container
  216. };
  217.  
  218. */
  219.  
  220. /*  Safe Fat Resources  */
  221. type 'sdes' { 
  222. Top:
  223.     hex string    = 
  224.         $"4E56 FFF0"      // SafeFatRsrc    LINK        A6, #-sysEnv1Size        ; Allocate a sysEnvRec
  225.         $"41EE FFF0"      //                LEA            -sysEnv1Size(A6), A0
  226.         $"7001"           //                MOVEQ        #1, D0                    ; On 6.X, Gestalt not be implemented...
  227.         $"A090"           //                _SysEnvirons    
  228.         $"4A40"           //                TST.W        D0
  229.         $"6640"           //                BNE.S        Install68K_60            ; if call fails, load up the 68K without FlushCache
  230.         $"0C68 0700 0004" //                CMPI        #$0700,systemVersion(A0)
  231.         $"6D38"           //                BLT.S        Install68K_60            ; if pre- 7.0, assume no cache        
  232.         $"303C A89F"      //                MOVE.W        #$A89F, D0                ; We have larger trap tables.  Is MixedMode installed?
  233.         $"A746"           //                _GetToolBoxTrapAddress                ; Leave _Unimplemented on the top of the stack...
  234.         $"2F08"           //                MOVE.L        A0, -(SP)                ; Unlk will clean this up
  235.         $"303C AAFE"      //                MOVE.W        #$AAFE, D0 
  236.         $"A746"           //                _GetToolBoxTrapAddress
  237.         $"B1D7"           //                CMPA.L        (SP), A0                
  238.         $"663E"           //                BNE.S        InstallPPCCode
  239.         $"41FA FFD4"      // Install68K_70    LEA            SafeFatRsrc, A0
  240.         $"30FC 6000"      //                MOVE.W        #$6000, (A0)+            ; Generate a BRA instruction
  241.         $"43FA 0044"      //                LEA            FatRD, A1
  242.         $"2029 0014"      //                MOVE.L        20(A1), D0                ; Get 68K code offset
  243.         $"5580"           //                SUBQ.L        #2, D0
  244.         $"3080"           //                MOVE.W        D0, (A0)                ; Fill in the second word of the BRA
  245.         $"303C A198"      //                MOVE.W        #$A198, D0                 ; Is _HWPriv implemented?
  246.         $"A346"           //                _GetOSTrapAddress
  247.         $"B1D7"           //                CMPA.L        (SP), A0
  248.         $"4E5E"           //                UNLK        A6
  249.         $"67B6"           //                BEQ.S        SafeFatRsrc
  250.         $"7001 A198"      //                _FlushInstructionCache
  251.         $"60B0"           //                BRA.S        SafeFatRsrc
  252.         $"4E5E"           // Install68K_60    UNLK        A6                        ; Old machine, FlushCache not supported
  253.         $"41FA FFAC"      //                LEA            SafeFatRsrc, A0                        
  254.         $"30FC 6000"      //                MOVE.W        #$6000, (A0)+            ; Generate a BRA instruction
  255.         $"43FA 001C"      //                LEA            FatRD, A1
  256.         $"2029 0014"      //                MOVE.L        20(A1), D0                ; Get 68K code offset
  257.         $"5580"           //                SUBQ.L        #2, D0
  258.         $"3080"           //                MOVE.W        D0, (A0)                ; Fill in the second word of the BRA
  259.         $"6098"           //                BRA.S        SafeFatRsrc
  260.         $"4E5E"           // InstallPPCCode    UNLK        A6
  261.         $"43FA FF94"      //                LEA            SafeFatRsrc, A1
  262.         $"41FA 0008"      //                LEA            FatRD, A0
  263.         $"7034"           //                MOVE.L        #52, D0
  264.         $"A02E"           //                _BlockMove                            ; Move R.D. to top of rsrc
  265.         $"6088";          //                BRA.S        SafeFatRsrc
  266.                           // FatRD    
  267.  
  268.     /* Routine Descriptor */
  269.     GoMixedModeTrapType             = _MixedModeMagic;
  270.     VersionType                        = kRoutineDescriptorVersion;
  271.     fill bit [7];
  272.     SelectorsAreIndexableType        = FALSE;
  273.     Reserved1Type;
  274.     Reserved2Type;
  275.     SelectorInfoType                = 0;
  276.     RoutineCountType                = 1;
  277.  
  278.     /* Routine Record */
  279.     ProcInfoType;
  280.     Reserved3Type;
  281.     ISAType                            = kM68kISA;
  282.     fill bit [11];
  283.     RoutineIsDispatchedDefaultType     = FALSE;
  284.     DontPassSelectorType            = FALSE;
  285.     UseNativeISAType                = TRUE;
  286.     FragmentNeedsPreparingType        = FALSE;
  287.     ProcDescriptorIsRelativeType    = TRUE;
  288.     ProcDescriptorType                = (BeginningOf68KCode-Top) / 8;
  289.     Reserved4Type;
  290.     SelectorType                    = 0;
  291.  
  292.     /* PowerPC Routine Record 1 */
  293.     ProcInfoType;
  294.     Reserved3Type;
  295.     ISAType    = kPowerPCISA;
  296.     fill bit [11];
  297.     RoutineIsDispatchedDefaultType     = FALSE;
  298.     DontPassSelectorType             = FALSE;
  299.     UseNativeISAType                 = TRUE;
  300.     FragmentNeedsPreparingType        = TRUE;
  301.     ProcDescriptorIsRelativeType    = TRUE;
  302.     ProcDescriptorType                 = (BeginningOfPowerPCCode-Top) / 8;
  303.     Reserved4Type;
  304.     SelectorType                     = 0;
  305.     Align LONG;
  306.  
  307. BeginningOf68KCode:
  308.     hex string;        // The 68k code starts here
  309.  
  310.     Align LONG;
  311.  
  312. BeginningOfPowerPCCode:
  313.     hex string;        // The PEF container starts here
  314. };
  315.  
  316.